home *** CD-ROM | disk | FTP | other *** search
/ Aminet 16 / Aminet 16 (1996)(GTI - Schatztruhe)[!][Dec 1996].iso / Aminet / comm / term / term_source.lha / Extras / Source / term-source.lha / KeyConvert.c < prev    next >
C/C++ Source or Header  |  1996-10-20  |  7KB  |  404 lines
  1. /*
  2. **    KeyConvert.c
  3. **
  4. **    Key code conversion routines
  5. **
  6. **    Copyright © 1990-1996 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. **
  9. **    :ts=4
  10. */
  11.  
  12. #ifndef _GLOBAL_H
  13. #include "Global.h"
  14. #endif
  15.  
  16.     /* ConvertKey():
  17.      *
  18.      *    The actual key conversion routine.
  19.      */
  20.  
  21. STATIC LONG
  22. ConvertKey(ULONG Qualifier,UWORD Code,ULONG Prev,STRPTR Buffer,LONG Len)
  23. {
  24.     LONG Actual;
  25.  
  26.         /* Fill in the defaults. */
  27.  
  28.     FakeInputEvent->ie_Code                = Code;
  29.     FakeInputEvent->ie_Qualifier        = Qualifier;
  30.     FakeInputEvent->ie_position.ie_addr    = (APTR)Prev;
  31.  
  32.         /* Clear the buffer (sortof). */
  33.  
  34.     Buffer[0] = 0;
  35.  
  36.         /* Convert the codes. */
  37.  
  38.     if((Actual = RawKeyConvert(FakeInputEvent,Buffer,Len,KeyMap)) > 0)
  39.         return(Actual);
  40.     else
  41.         return(0);
  42. }
  43.  
  44.     /* ConvertTheKey(STRPTR Buffer,LONG *Len,UWORD Code,UWORD Qualifier,ULONG Prev):
  45.      *
  46.      *    Much more simplified raw key conversion routine.
  47.      */
  48.  
  49. LONG
  50. ConvertTheKey(STRPTR Buffer,LONG *Len,UWORD Code,UWORD Qualifier,ULONG Prev)
  51. {
  52.     if(Buffer)
  53.         Buffer[0] = 0;
  54.  
  55.     if(Len)
  56.         *Len = 0;
  57.  
  58.         /* Key was pressed, not released. */
  59.  
  60.     if(!(Code & IECODE_UP_PREFIX))
  61.     {
  62.             /* These are the sequences mapped to special
  63.              * control keys (cursor keys, function keys,
  64.              * the help key).
  65.              */
  66.  
  67.         STATIC struct { STRPTR RawCode; UBYTE Result; } ConversionTable[15] =
  68.         {
  69.             (STRPTR)"A",    CUP,
  70.             (STRPTR)"B",    CDN,
  71.             (STRPTR)"C",    CFW,
  72.             (STRPTR)"D",    CBK,
  73.  
  74.             (STRPTR)"?~",    HLP,
  75.  
  76.             (STRPTR)"0~",    FN1,
  77.             (STRPTR)"1~",    FN2,
  78.             (STRPTR)"2~",    FN3,
  79.             (STRPTR)"3~",    FN4,
  80.             (STRPTR)"4~",    FN5,
  81.             (STRPTR)"5~",    FN6,
  82.             (STRPTR)"6~",    FN7,
  83.             (STRPTR)"7~",    FN8,
  84.             (STRPTR)"8~",    FN9,
  85.             (STRPTR)"9~",    F10
  86.         };
  87.  
  88.         STATIC UBYTE SeqLens[15] = { 1,1,1,1,2,2,2,2,2,2,2,2,2,2,2 };
  89.  
  90.         UBYTE    ConvertBuffer[256];
  91.         LONG    Actual;
  92.  
  93.             /* If it's a function or cursor key, clear the qualifier. */
  94.  
  95.         if(Code >= CURSOR_UP_CODE && Code <= F10_CODE)
  96.             Qualifier = NULL;
  97.         else
  98.         {
  99.                 /* Does it have a numeric keypad qualifier set? */
  100.  
  101.             if((Qualifier & (IEQUALIFIER_NUMERICPAD | IEQUALIFIER_CONTROL)) == (IEQUALIFIER_NUMERICPAD | IEQUALIFIER_CONTROL))
  102.             {
  103.                 STRPTR String = NULL;
  104.  
  105.                     /* Look at the vanilla result. */
  106.  
  107.                 if(ConvertKey(Qualifier & ~(CONTROL_KEY | SHIFT_KEY | ALT_KEY),Code,Prev,ConvertBuffer,1))
  108.                 {
  109.                         /* Take a look at the results. */
  110.  
  111.                     switch(ConvertBuffer[0])
  112.                     {
  113.                         case '(':
  114.                         case '[':
  115.                         case '{':
  116.  
  117.                             String = "\033OP";
  118.                             break;
  119.  
  120.                         case ')':
  121.                         case ']':
  122.                         case '}':
  123.  
  124.                             String = "\033OQ";
  125.                             break;
  126.  
  127.                         case '/':
  128.  
  129.                             String = "\033OR";
  130.                             break;
  131.  
  132.                         case '*':
  133.  
  134.                             String = "\033OS";
  135.                             break;
  136.  
  137.                         default:
  138.  
  139.                             String = NULL;
  140.                             break;
  141.                     }
  142.                 }
  143.  
  144.                 if(!String)
  145.                 {
  146.                     switch(Code)
  147.                     {
  148.                         case 0x5A:
  149.  
  150.                             String = "\033OP";
  151.                             break;
  152.  
  153.                         case 0x5B:
  154.  
  155.                             String = "\033OQ";
  156.                             break;
  157.  
  158.                         case 0x5C:
  159.  
  160.                             String = "\033OR";
  161.                             break;
  162.  
  163.                         case 0x5D:
  164.  
  165.                             String = "\033OS";
  166.                             break;
  167.                     }
  168.                 }
  169.  
  170.                     /* Return the PFx key code. */
  171.  
  172.                 if(String)
  173.                 {
  174.                     if(Buffer)
  175.                         CopyMem(String,Buffer,3);
  176.  
  177.                     if(Len)
  178.                         *Len = 3;
  179.  
  180.                     return('\033');
  181.                 }
  182.             }
  183.  
  184.                 /* Does it have a shift qualifier set? */
  185.  
  186.             if(Qualifier & SHIFT_KEY)
  187.             {
  188.                     /* Do the conversion... */
  189.  
  190.                 if(ConvertKey(Qualifier & ~SHIFT_KEY,Code,Prev,ConvertBuffer,1))
  191.                 {
  192.                         /* Did it produce a tab key? If so, transfer
  193.                          * Esc tab instead.
  194.                          */
  195.  
  196.                     if(ConvertBuffer[0] == '\t')
  197.                     {
  198.                         if(Len)
  199.                             *Len = 2;
  200.  
  201.                         if(Buffer)
  202.                             CopyMem("\033\t",Buffer,2);
  203.  
  204.                         return('\033');
  205.                     }
  206.                 }
  207.             }
  208.  
  209.                 /* Does it have the control qualifier set? */
  210.  
  211.             if(Qualifier & CONTROL_KEY)
  212.             {
  213.                     /* Do the conversion... */
  214.  
  215.                 if(ConvertKey(Qualifier & ~CONTROL_KEY,Code,Prev,ConvertBuffer,1))
  216.                 {
  217.                         /* Did it produce a space or an `at' sign? */
  218.  
  219.                     switch(ConvertBuffer[0])
  220.                     {
  221.                             /* NUL */
  222.  
  223.                         case ' ':
  224.                         case '@':
  225.                         case '2':
  226.  
  227.                             if(Len)
  228.                                 *Len = 1;
  229.  
  230.                             if(Buffer)
  231.                                 Buffer[0] = 0;
  232.  
  233.                             return(0);
  234.  
  235.                             /* Escape */
  236.  
  237.                         case '3':
  238.                         case '[':
  239.  
  240.                             if(Len)
  241.                                 *Len = 1;
  242.  
  243.                             if(Buffer)
  244.                                 Buffer[0] = 0x1B;
  245.  
  246.                             return(0x1B);
  247.  
  248.                             /* FS */
  249.  
  250.                         case '4':
  251.                         case '/':
  252.  
  253.                             if(Len)
  254.                                 *Len = 1;
  255.  
  256.                             if(Buffer)
  257.                                 Buffer[0] = 0x1C;
  258.  
  259.                             return(0x1C);
  260.  
  261.                             /* GS */
  262.  
  263.                         case '5':
  264.                         case ']':
  265.  
  266.                             if(Len)
  267.                                 *Len = 1;
  268.  
  269.                             if(Buffer)
  270.                                 Buffer[0] = 0x1D;
  271.  
  272.                             return(0x1D);
  273.  
  274.                             /* RS */
  275.  
  276.                         case '6':
  277.                         case '~':
  278.  
  279.                             if(Len)
  280.                                 *Len = 1;
  281.  
  282.                             if(Buffer)
  283.                                 Buffer[0] = 0x1E;
  284.  
  285.                             return(0x1E);
  286.  
  287.  
  288.                             /* US */
  289.  
  290.                         case '7':
  291.                         case '?':
  292.  
  293.                             if(Len)
  294.                                 *Len = 1;
  295.  
  296.                             if(Buffer)
  297.                                 Buffer[0] = 0x1F;
  298.  
  299.                             return(0x1F);
  300.                     }
  301.                 }
  302.             }
  303.         }
  304.  
  305.             /* Do the final conversion... */
  306.  
  307.         if(Actual = ConvertKey(Qualifier,Code,Prev,ConvertBuffer,sizeof(ConvertBuffer) - 1))
  308.         {
  309.                 /* Are we to swap the backspace and
  310.                  * delete keys?
  311.                  */
  312.  
  313.             if(Config->EmulationConfig->SwapBSDelete)
  314.             {
  315.                 LONG i;
  316.  
  317.                 for(i = 0 ; i < Actual ; i++)
  318.                 {
  319.                     if(ConvertBuffer[i] == BKS)
  320.                         ConvertBuffer[i] = DEL;
  321.                     else
  322.                     {
  323.                         if(ConvertBuffer[i] == DEL)
  324.                             ConvertBuffer[i] = BKS;
  325.                     }
  326.                 }
  327.             }
  328.  
  329.                 /* Translated sequence starts
  330.                  * with a CSI, let's have a look
  331.                  * at the associated control
  332.                  * key.
  333.                  */
  334.  
  335.             if(ConvertBuffer[0] == CSI)
  336.             {
  337.                 LONG i;
  338.  
  339.                 for(i = 0 ; i < sizeof(SeqLens) ; i++)
  340.                 {
  341.                         /* Does it match? */
  342.  
  343.                     if(!memcmp(&ConvertBuffer[1],ConversionTable[i].RawCode,SeqLens[i]))
  344.                     {
  345.                             /* Store the length. */
  346.  
  347.                         if(Len)
  348.                             *Len = 1;
  349.  
  350.                             /* Store the result. */
  351.  
  352.                         if(Buffer)
  353.                         {
  354.                             Buffer[0] = ConversionTable[i].Result;
  355.                             Buffer[1] = 0;
  356.                         }
  357.  
  358.                         return(ConversionTable[i].Result);
  359.                     }
  360.                 }
  361.             }
  362.  
  363.                 /* Store the number of characters converted. */
  364.  
  365.             if(Len)
  366.                 *Len = Actual;
  367.  
  368.                 /* Store the converted characters. */
  369.  
  370.             if(Buffer)
  371.                 CopyMem(ConvertBuffer,Buffer,Actual);
  372.  
  373.             return(ConvertBuffer[0]);
  374.         }
  375.     }
  376.  
  377.     return(0);
  378. }
  379.  
  380.     /* KeyConvert(struct IntuiMessage *Message,STRPTR Buffer):
  381.      *
  382.      *    Convert a raw key information according to the
  383.      *    current keymap settings.
  384.      */
  385.  
  386. LONG
  387. KeyConvert(struct IntuiMessage *Message,STRPTR Buffer,LONG *Len)
  388. {
  389.         /* Is this really a keyboard event? */
  390.  
  391.     if(Message->Class == IDCMP_RAWKEY)
  392.         return(ConvertTheKey(Buffer,Len,Message->Code,Message->Qualifier,*(ULONG *)Message->IAddress));
  393.     else
  394.     {
  395.         if(Buffer)
  396.             Buffer[0] = 0;
  397.  
  398.         if(Len)
  399.             *Len = 0;
  400.  
  401.         return(0);
  402.     }
  403. }
  404.